Jenkins

Overview

Jenkins is a widely used automation server that enables teams to build, test, and deploy applications through Continuous Integration and Continuous Delivery (CI/CD) pipelines.

By integrating Jenkins with Enov8, you can automatically push information about deployed application versions to Enov8 as part of your deployment pipeline. Jenkins sends deployment details such as the System, Environment, and Version to Enov8 using a REST API request.

Once received, Enov8 updates the corresponding environment instance with the deployed version, ensuring the platform accurately reflects the latest deployment state. This automated synchronization helps maintain a reliable and up-to-date view of your application landscape, improving environment visibility, deployment tracking, and operational governance.

After a successful deployment, Jenkins sends a REST API request to Enov8 containing:

• System – The application or system deployed
• Environment – The target environment where the deployment occurred
• Version – The deployed build or release version

Enov8 uses this information to update the deployed version for the relevant environment instance.

---

Prerequisites

Before configuring the integration, ensure the following requirements are met.

Jenkins Access and Permissions

You must have access to configure or modify Jenkins pipelines and add post-deployment steps within your Jenkins jobs.

The HTTP Request Plugin must also be installed and enabled in Jenkins to allow API calls.

Enov8 Access and Permissions

Ensure you have access to the Enov8 platform and that the System and Environment records already exist in Enov8.

note

The System and Environment values sent from Jenkins must match the corresponding records configured in Enov8.

Enov8 REST API Authentication

Jenkins must authenticate with the Enov8 API using the following headers.

app-id: your_app_id
user-id: your_user_id
app-key: your_app_key
Content-Type: application/json

Integration Steps

Configure Jenkins Pipeline

Add a post-deployment stage in your Jenkins pipeline that will send deployment information to Enov8.

Example use case

A team deploys the Salesforce application into the SIT Env environment. Once deployment completes successfully, Jenkins sends a request to Enov8 with a version such as v1.0.143522. Enov8 receives the request and updates the version recorded for that system in that environment.

Sample request body

{
  "System": "Salesforce",
  "Environment": "SIT Env",
  "Version": "v1.0.143522"
}

Field Definitions

Field	Description
System	The name of the application or system in Enov8 whose deployed version is being updated.
Environment	The Enov8 environment where the deployment occurred, such as DEV, SIT, UAT, or PROD.
Version	The deployed build or release version that Enov8 should record.

Sample Jenkins Pipeline

The following example shows a simple Jenkins pipeline that generates a version value, prepares the payload, and calls the Enov8 API.

pipeline {
    agent any

    environment {
        FAKE_VERSION = "v1.0.${new Date().format('HHmmss')}"
        ENOV8_API = "https://demo.enov8.com/ecosystem/api/environmentinstance"
        APP_ID = "yourapiuser"
        APP_USER = "yourapiuser"
        APP_KEY = "yourapikey"
    }

    stages {
        stage('Prepare Payload') {
            steps {
                script {
                    payload = '''
                    {
                      "System": "Salesforce",
                      "Environment": "SIT Env",
                      "Version": "${env.FAKE_VERSION}"
                    }
                    '''

                    echo "=== Payload ==="
                    echo payload
                }
            }
        }

        stage('Call Enov8 API') {
            steps {
                script {
                    def response = httpRequest(
                        httpMode: 'PUT',
                        url: env.ENOV8_API,
                        requestBody: payload,
                        contentType: 'APPLICATION_JSON',
                        validResponseCodes: '200',
                        customHeaders: [
                            [name: 'app-id', value: env.APP_ID],
                            [name: 'user-id', value: env.APP_USER],
                            [name: 'app-key', value: env.APP_KEY]
                        ]
                    )
                    echo "Enov8 responded with status: ${response.status}"
                    echo "Enov8 response content: ${response.content}"
                }
            }
        }
    }
}

---

How the Pipeline Works

The pipeline contains two main stages.

Prepare Payload

In the Prepare Payload stage, Jenkins builds the JSON payload to send to Enov8.

The payload includes:

• System name
• Environment name
• Version

In this example, the version is dynamically generated using the current time.

In a production process, the version would usually come from:

• Build number
• Release tag
• Package version
• Artifact version

---

Call Enov8 API

In the Call Enov8 API stage, Jenkins sends an HTTP request to the Enov8 API endpoint.

The request:

• Uses the PUT method
• Includes the JSON payload
• Includes the authentication headers

If successful, Jenkins logs:

• The response status
• The response body

---

Recommended Production Approach

For production use:

• Do not hardcode credentials directly in the pipeline
• Store them securely in Jenkins credentials
• Inject them into the pipeline at runtime

It is also recommended to:

• Pass system name, environment name, and version as pipeline parameters
• Or derive them from the deployment context

---

The sample uses PUT, which is appropriate when the API is updating an existing environment instance record.

If your Enov8 API configuration expects POST instead, update the httpMode value accordingly.

Always confirm the correct HTTP method with your Enov8 API specification before promoting the integration to production.

Best Practices

• Store secrets in Jenkins credentials
• Mask authentication header values in Jenkins console output
• Trigger the Enov8 update only after a successful deployment
• Use the actual deployed artifact version
• Add retry or failure-handling logic if the update is part of a critical release process

---

Summary

This integration allows Jenkins to automatically update Enov8 after deployment by sending a REST API request containing:

• System
• Environment
• Version

This improves:

• Deployment traceability
• Automation
• Alignment between Enov8 and real deployment activity across environments.